

#include "../log/xglog.h"
#include <unistd.h>

void test_log(const std::string &name)
{
    //从全局管理中获取指定的日志器——按照日志器名称进行测试
    xglog::logger::ptr log=xglog::LoggerManager::GetInstance().getLogger(name);
    INFO("%s","测试开始...");
    log->debug("%s","测试日志");
    log->info("%s","测试日志");
    log->warn("%s","测试日志");
    log->error("%s","测试日志");
    log->fatal("%s","测试日志");

    INFO("%s","测试结束...");

}
// 使用示例
int main()
{
    std::unique_ptr<xglog::LoggerBuilder> builder(new xglog::GlobalLoggerBuilder());
    builder->buildLoggerName("ASYNC-LOG");                    // 日志器名称
    builder->buildLoggerType(xglog::Logger_Type::LOG_ASYNC);  // 异步日志器
    builder->buildLoggerLevel(xglog::LogLevel::value::ERROR); // 设置日志最低输出等级
    builder->buildLoggerFormat("[%c][%f:%l]%m%n");
    builder->buildLoggerSink<xglog::StdoutSink>();                   // 添加落地方向-标准输出
    builder->buildLoggerSink<xglog::FileSink>("./logfile/test.log"); // 添加落地方向-指定文件
    builder->buildLoggerSink<xglog::RollBySizeSink>("./logfile/test.log",1024*1024*10); // 添加落地方向-滚动文件(按照文件大小10M,切换一次)

    xglog::logger::ptr log = builder->build();//通过建造者模式生成一个日志器
    test_log("ASYNC-LOG");

    return 0;
}
// // 测试日志管理器模块
// void test_log()
// {
//     xglog::logger::ptr log = xglog::LoggerManager::GetInstance().getLogger("ASYNC-LOG");
//     log->debug(__FILE__, __LINE__, "%s", "测试日志...");
//     log->info(__FILE__, __LINE__, "%s", "测试日志...");
//     log->warn(__FILE__, __LINE__, "%s", "测试日志...");
//     log->error(__FILE__, __LINE__, "%s", "测试日志...");
//     log->fatal(__FILE__, __LINE__, "%s", "测试日志...");

//     size_t count = 0;
//     size_t begin1 = clock();
//     // 在这里测试出现了个问题,程序一直在死循环打印
//     // 问题在于交换缓冲区时使用传值，应该使用传引用
//     // 导致生产缓冲区一直不变
//     // 交换的一直是生产缓冲区的拷贝
//     // 从而导致一直唤醒消费线程进行对生产缓冲区数据的处理
//     while (count < 500000)
//     {
//         log->fatal(__FILE__, __LINE__, "测试日志-%zu", count);
//         count++;
//     }
//     size_t end1 = clock();
//     std::cout << "异步日志器花费的时间：" << end1 - begin1 << std::endl;
// }

// //测试部分代码
// int main()
// {
//     DEBUG("%s","测试日志......");
//     INFO("%s","测试日志......");
//     WARN("%s","测试日志......");
//     ERROR("%s","测试日志......");
//     FATAL("%s","测试日志......");

//     xglog::logger::ptr log = xglog::LoggerManager::GetInstance().getLogger("ASYNC-LOG");
//     log->debug("%s", "测试日志...");
//     log->info("%s", "测试日志...");
//     log->warn("%s", "测试日志...");
//     log->error("%s", "测试日志...");
//     log->fatal("%s", "测试日志...");
//     size_t count = 0;
//     size_t begin1 = clock();
//     // 在这里测试出现了个问题,程序一直在死循环打印
//     // 问题在于交换缓冲区时使用传值，应该使用传引用
//     // 导致生产缓冲区一直不变
//     // 交换的一直是生产缓冲区的拷贝
//     // 从而导致一直唤醒消费线程进行对生产缓冲区数据的处理
//     while (count < 500000)
//     {
//         log->fatal(__FILE__, __LINE__, "测试日志-%zu", count);
//         count++;
//     }
//     size_t end1 = clock();
//     std::cout << "异步日志器花费的时间：" << end1 - begin1 << std::endl;

// std::unique_ptr<xglog::LoggerBuilder> builder(new xglog::GlobalLoggerBuilder());
// builder->buildLoggerName("ASYNC-LOG");                    // 日志器名称
// builder->buildLoggerType(xglog::Logger_Type::LOG_ASYNC);  // 异步日志器
// builder->buildLoggerLevel(xglog::LogLevel::value::ERROR); // 日志最低输出等级
// builder->buildLoggerFormat("[%c][%f:%l]%m%n");
// xglog::logger::ptr log = builder->build();;
// log->debug("%s", "测试日志...");
// log->info("%s", "测试日志...");
// log->warn("%s", "测试日志...");
// log->error("%s", "测试日志...");
// log->fatal("%s", "测试日志...");

// size_t count = 0;
// size_t begin1 = clock();
// // 在这里测试出现了个问题,程序一直在死循环打印
// // 问题在于交换缓冲区时使用传值，应该使用传引用
// // 导致生产缓冲区一直不变
// // 交换的一直是生产缓冲区的拷贝
// // 从而导致一直唤醒消费线程进行对生产缓冲区数据的处理
// while (count < 500000)
// {
//     log->fatal("测试日志-%zu", count);
//     count++;
// }
// size_t end1 = clock();
// std::cout << "异步日志器花费的时间：" << end1 - begin1 << std::endl;
// ##################################################################################
// std::unique_ptr<xglog::LoggerBuilder> builder(new xglog::GlobalLoggerBuilder());
// builder->buildLoggerName("ASYNC-LOG");                    // 日志器名称
// builder->buildLoggerType(xglog::Logger_Type::LOG_ASYNC);  // 异步日志器
// builder->buildLoggerLevel(xglog::LogLevel::value::ERROR); // 日志最低输出等级
// builder->buildLoggerFormat("[%c]%m%n");
// builder->buildLoggerSink<xglog::StdoutSink>();                    // 添加落地方向-标准输出
// builder->buildLoggerSink<xglog::FileSink>("./logfile/async.log"); // 添加落地方向-指定文件

// xglog::logger::ptr log = builder->build();
// test_log();
// #################################################################################
// 测试缓冲区模块
// 读取./logfile/test.log文件写入缓冲区中
// 再将缓冲区中的内容写到一个新的文件./logfile/tmp.log中
//  std::string filename="./logfile/test.log";
//  std::string filename2="./logfile/tmp.log";
//  std::ifstream ifs(filename,std::ios::binary);
//  if(ifs.is_open()==false)
//  {
//      std::cout<<"open fail!!\n";
//      return -1;
//  }
//  ifs.seekg(0,std::ios::end);//偏移到文件末尾
//  //获取文件大小
//  size_t fsize=ifs.tellg();//获取当前位置相较于起始位置的偏移量
//  ifs.seekg(0,std::ios::beg);//重新跳转到起始位置
//  std::string body;
//  body.resize(fsize);

// std::cout<<"fize:"<<fsize<<std::endl;
// ifs.read(&body[0],fsize);
// std::cout<<"body size:"<<body.size()<<std::endl;
// ifs.close();

// xglog::Buffer buffer;
// // buffer.push(body.c_str(),body.size());
// for(int i=0;i<body.size();i++)
//     buffer.push(&body[i],1);

// std::ofstream ofs(filename2,std::ios::binary);
// if(ofs.is_open()==false)
// {
//     std::cout<<"open erro!!\n";
//     return -1;
// }
// size_t n=buffer.readAbleSize();
// for(int i=0;i<n;i++)
// {
//     ofs.write(buffer.begin(),1);
//     buffer.moveRead(1);//######
// }
// ofs.close();

// ###############################################################################################
// ###############################################################################################
//  测试建造者模式下的局部日志器(同步)
// 通过基类建造者生产日志器(同步or异步)
// 异步
// std::unique_ptr<xglog::LoggerBuilder> builder(new xglog::GlobalLoggerBuilder());
// builder->buildLoggerName("ASYNC-LOG");                    // 日志器名称
// builder->buildLoggerType(xglog::Logger_Type::LOG_ASYNC);  // 异步日志器
// builder->buildLoggerLevel(xglog::LogLevel::value::ERROR); // 日志最低输出等级
// builder->buildLoggerFormat("[%c]%m%n");
// builder->buildLoggerSink<xglog::StdoutSink>();                    // 添加落地方向-标准输出
// builder->buildLoggerSink<xglog::FileSink>("./logfile/async.log"); // 添加落地方向-指定文件

// xglog::logger::ptr log = builder->build();

// log->debug(__FILE__, __LINE__, "%s", "测试日志...");
// log->info(__FILE__, __LINE__, "%s", "测试日志...");
// log->warn(__FILE__, __LINE__, "%s", "测试日志...");
// log->error(__FILE__, __LINE__, "%s", "测试日志...");
// log->fatal(__FILE__, __LINE__, "%s", "测试日志...");

// size_t count = 0;
// size_t begin1 = clock();
// // 在这里测试出现了个问题,程序一直在死循环打印
// //问题在于交换缓冲区时使用传值，应该使用传引用
// //导致生产缓冲区一直不变
// //交换的一直是生产缓冲区的拷贝
// //从而导致一直唤醒消费线程进行对生产缓冲区数据的处理
// while (count < 500000)
// {
//     log->fatal(__FILE__, __LINE__, "测试日志-%zu", count);
//     count++;
// }
// size_t end1 = clock();
// std::cout << "异步日志器花费的时间：" << end1 - begin1 << std::endl;
// 走到这里，程序运行完了，尝试进行析构，释放异步日志器
// 此时的日志器，调用内部的析构，会唤醒消费线程
// 消费线程从而继续将剩下的数据 进行处理
// 由于是死循环处理，当身缠缓冲区的数据处理完后才会退出
// 所以，消费线程此时被唤醒，由于缓冲区交换时是拷贝，所以生产缓冲区一直非空
// 导致消费线程一直在死循环
// 主线程同时一直在等待消费线程
// ###############################################################################################
// ###############################################################################################

// 同步
//  std::unique_ptr<xglog::LoggerBuilder> builder(new xglog::LocalLoggerBuilder());
//  builder->buildLoggerName("SYNC-LOG");                    // 日志器名称
//  builder->buildLoggerType(xglog::Logger_Type::LOG_SYNC);  // 同步日志器
//  builder->buildLoggerLevel(xglog::LogLevel::value::INFO); // 日志最低输出等级
//  builder->buildLoggerFormat("[%c]%m%n");
//  builder->buildLoggerSink<xglog::StdoutSink>();//添加落地方向-标准输出
//  builder->buildLoggerSink<xglog::FileSink>("./logfile/test.log");//添加落地方向-指定文件

// xglog::logger::ptr log=builder->build();

// log->debug(__FILE__, __LINE__, "%s", "测试日志...");
// log->info(__FILE__, __LINE__, "%s", "测试日志...");
// log->warn(__FILE__, __LINE__, "%s", "测试日志...");
// log->error(__FILE__, __LINE__, "%s", "测试日志...");
// log->fatal(__FILE__, __LINE__, "%s", "测试日志...");

// size_t count = 0;
// size_t begin2=clock();
// while (count < 500000)
// {
//     log->fatal(__FILE__, __LINE__, "测试日志-%d", count++);
// }
// size_t end2=clock();
// std::cout<<"同步日志器花费的时间："<<end2-begin2<<std::endl;
// ########################################################################################
// 测试同步日志器模块
// std::string _logger_name = "测试同步日志器";
// xglog::LogLevel::value limit_level = xglog::LogLevel::value::WARN;
// xglog::Formatter::ptr format(new xglog::Formatter); // 日志格式化模块
// xglog::SinkPtr stdout_sink = xglog::SinkFactory::createSink<xglog::StdoutSink>();
// xglog::SinkPtr file_sink = xglog::SinkFactory::createSink<xglog::FileSink>("./logfile/test.log");
// xglog::SinkPtr roll_sink = xglog::SinkFactory::createSink<xglog::RollBySizeSink>("./logfile/base-", 1024 * 1024);
// std::vector<xglog::SinkPtr> sinks = {stdout_sink, file_sink, roll_sink};
// xglog::logger::ptr log(new xglog::Synclogger(_logger_name, limit_level, format, sinks));

// log->debug(__FILE__, __LINE__, "%s", "测试日志...");
// log->info(__FILE__, __LINE__, "%s", "测试日志...");
// log->warn(__FILE__, __LINE__, "%s", "测试日志...");
// log->error(__FILE__, __LINE__, "%s", "测试日志...");
// log->fatal(__FILE__, __LINE__, "%s", "测试日志...");

// size_t cur_size = 0, count = 0;
// while (cur_size < 10 * 1024 * 1024)
// {
//     log->fatal(__FILE__, __LINE__, "测试日志-%d", count++);
//     cur_size += 100;
// }
//     return 0;
// }